/** * @description 监测页面组件 *
用于显示和管理患者的脑部监测数据，包括左右脑阻抗值、稳定系数等 *
提供实时监测、数据回放、报告生成等功能 */
<template>
  <div class="bg">
    <MyHeader
      :username="username"
      :navItems="navItems"
      :id="userInfo.id"
      @navClick="handleNavClick"
      @menuItemClick="handleMenuItemClick"
      @homeClick="handleHomeClick"
      :isMonitoring="isMonitoring" />

    <!-- 使用新组件替换原来的患者信息区域 -->
    <PatientInformationArea :patient-info="patientInfo" />

    <section class="stability-section">
      <div class="patient-info-title">稳定系数</div>
    </section>

    <StabilityCoefficient
      :left-brain-latest-value="leftBrainLatestValue"
      :left-brain-max-value="leftBrainMaxValue"
      :right-brain-latest-value="rightBrainLatestValue"
      :right-brain-max-value="rightBrainMaxValue"
      :all-brain-latest-value="allBrainLatestValue"
      :all-brain-max-value="allBrainMaxValue" />

    <div class="cranialPressure">
      <span class="title">颅内压</span>
      <span class="status">状态</span>
    </div>

    <div style="width: 100%; height: 100px">
      <l-echart ref="chartRef" @finished="init"></l-echart>
    </div>

    <!-- 添加 EditInformation 组件 -->
    <EditInformation
      v-model="showEditDialog"
      :patient-info="patientInfo"
      @update-success="handleUpdateSuccess" />

    <StartMonitoringDialog
      v-model="showStartMonitoringDialog"
      @confirm="handleStartMonitoring" />

    <!--    电极检测中-->
    <ElectrodeDetection v-model="showElectrodeDetection" />

    <!--    电极佩戴异常-->
    <AbnormalElectrode
      :value="showAbnormalElectrode"
      @input="(val) => (showAbnormalElectrode = val)"
      @handle="handleAbnormalElectrode" />

    <!-- 报告弹框 -->
    <LaboratoryReport
      v-if="showReportDialog"
      :reportData="patientInfo"
      :preprocessedData="preprocessedReportData"
      @close="handleReportClose"
      @updateTable="handleUpdateSuccess" />

    <!-- 修改密码弹框 -->
    <ChangePassword
      v-if="showChangePassword"
      @close="handleCloseChangePassword"
      @success="handlePasswordChangeSuccess" />

    <!-- 账号管理弹框 -->
    <AccountManagement
      v-if="showAccountManagement"
      @close="handleCloseAccountManagement" />

    <!-- 资料中心弹框 -->
    <DataCenterDialog v-if="showDataCenter" @close="handleCloseDataCenter" />

    <!-- 数据回放弹框 -->
    <DataPlaybackDialog
      v-if="showDataPlaybackDialog"
      v-model="showDataPlaybackDialog"
      @close="handleCloseDataPlayback"
      @playback="handleDataPlayback" />

    <!-- 退出确认弹框 -->
    <div class="exit" v-if="showExitConfirm">
      <div class="exitImg">
        <div>
          <button class="transparent-button" @click="handleCancelExit">
            取消
          </button>
        </div>
        <div>
          <button class="confirm-button" @click="handleConfirmExit">
            确定
          </button>
        </div>
      </div>
    </div>

    <div class="frequency-display">
      <span>频率 【50000Hz】</span>
    </div>

    <div class="display-time">
      <div style="margin-right: 20px">开始时间: {{ startTimeDisplay }}</div>
      <div style="margin-right: 20px">监测时间: {{ monitoringTimeDisplay }}</div>
      <div style="margin-right: 20px">电量: {{ batteryLevel }}%</div>
      <div style="margin-right: 20px">蓝牙状态: {{ bluetoothStatus }}</div>
    </div>
  </div>
</template>

<script>
import * as echarts from '@/uni_modules/lime-echart/static/echarts.min'
import { mapState, mapMutations, mapActions } from 'vuex'
import {
  readJsonFromFile,
  updateJsonById,
  writeJsonToFile,
} from '@/utils/fileUtil'
import RainbowProgressBar from '@/components/RainbowProgressBar/RainbowProgressBar.vue'
import MyHeader from './components/MyHeader.vue'
import EditInformation from './components/EditInformation.vue'
import PatientInformationArea from './components/PatientInformationArea.vue'
import StartMonitoringDialog from './components/StartMonitoringDialog.vue'
import ElectrodeDetection from './components/ElectrodeDetection.vue'
import { toast } from '@/utils'
import { handleConnect } from '@/public/ConnectBLE'
import MyLoad from '@/components/MyLoad/MyLoad.vue'
import AbnormalElectrode from './components/AbnormalElectrode.vue'
import {
  ab2hex,
  checkPackage,
  convertFloat,
  writeBLEState,
} from '@/public/BluetoothFun'
import LaboratoryReport from '@/components/LaboratoryReport/LaboratoryReport.vue'
import ChangePassword from '@/pages/userMenu/components/ChangePassword.vue'
import AccountManagement from '@/pages/userMenu/components/AccountManagement.vue'
import DataCenterDialog from '@/pages/userMenu/components/DataCenterDialog.vue'
import DataPlaybackDialog from './components/DataPlaybackDialog.vue'
import StabilityCoefficient from './components/StabilityCoefficient.vue'
import { checkAbnormalImpedance } from '@/utils/monitorUtils'

// 定义阻抗数据数组的最大长度
const MAX_IMPEDANCE_DATA_LENGTH = 1285

// 全局变量，存储阻抗数据
let impedanceL = [] // 左脑阻抗数据
let impedanceR = [] // 右脑阻抗数据
let impedanceAll = [] // 全脑阻抗数据

export default {
  name: 'Monitor',
  components: {
    MyLoad,
    RainbowProgressBar,
    MyHeader,
    EditInformation,
    PatientInformationArea,
    StartMonitoringDialog,
    ElectrodeDetection,
    AbnormalElectrode,
    LaboratoryReport,
    ChangePassword,
    AccountManagement,
    DataCenterDialog,
    DataPlaybackDialog,
    StabilityCoefficient,
  },
  watch: {
    // 监听蓝牙数据变化，当收到新数据时进行处理
    originalData(newValue) {
      console.log('接收的数据', ab2hex(newValue))
      this.checkFormat(newValue)
    },    // 监听蓝牙连接状态
    isConnected(newValue) {
      if (newValue === false) {
        // 更新蓝牙状态
        this.bluetoothStatus = '未连接'
        this.batteryLevel = 0
        
        // 连接断开且不是用户手动断开的情况下，尝试重新连接上一个设备
        if (!this.isManualDisconnect && this.$store.state.deviceId) {
          console.log('蓝牙连接断开，开始尝试自动重连...')
          // 防止连续多次尝试重连
          if (!this.isReconnecting) {
            this.isReconnecting = true
            
            // 启动持续重连机制
            this.startReconnection()
          }
        } else if (this.isManualDisconnect) {
          // 重置手动断开标志，以便下次自动断开时能够自动重连
          this.isManualDisconnect = false
          console.log('用户手动断开连接，不尝试重连')
        }
      } else {
        this.bluetoothStatus = '已连接'
        // 如果是重连成功，根据当前监测状态恢复监测
        if (this.isReconnecting) {
          this.isReconnecting = false
          console.log('蓝牙重连成功')
          
          // 如果正在监测，重新发送深度监测指令
          if (this.isMonitoring) {
            console.log('检测到正在监测状态，重新发送深度监测指令...')
            setTimeout(() => {
              writeBLEState(17) // 发送深度监测指令
            }, 2000)
          }
        }
      }
    },
  },
  data() {
    return {
      // 基础信息
      username: '', // 当前登录用户的用户名
      patientId: '', // 当前监测患者的ID
      patientInfo: null, // 当前患者的详细信息对象
      
      // 蓝牙重连相关
      isReconnecting: false, // 标记是否正在重连中，防止重复重连
      isManualDisconnect: false, // 标记是否是用户手动断开连接
      reconnectCount: 0, // 重连尝试次数
      reconnectTimer: null, // 重连定时器

      // 左脑第一个值
      leftBrainFirstValue: null,
      // 右脑第一个值
      rightBrainFirstValue: null,
      // 全脑第一个值
      allBrainFirstValue: null,

      // 对话框显示控制
      showEditDialog: false, // 编辑患者信息对话框的显示状态
      showStartMonitoringDialog: false, // 开始监测对话框的显示状态
      showElectrodeDetection: false, // 电极检测对话框的显示状态
      showAbnormalElectrode: false, // 异常电极提示对话框的显示状态
      showDataPlaybackDialog: false, // 数据回放对话框的显示状态
      showReportDialog: false, // 报告生成对话框的显示状态
      showChangePassword: false, // 修改密码对话框的显示状态
      showAccountManagement: false, // 账号管理对话框的显示状态
      showDataCenter: false, // 资料中心对话框的显示状态
      showExitConfirm: false, // 退出确认对话框的显示状态

      // 监测状态控制
      isFirstDetection: true, // 标记是否为首次检测
      isMonitoring: false, // 标记是否正在进行监测
      isFirstDataAfterDetection: false, // 标记是否为电极检测通过后的第一条数据
      
      // 新增：用于跟踪正式监测后的数据条数
      formalMonitoringDataCount: 0,
      // 新增：标记是否正在收集前5条数据
      isCollectingInitialData: false,
      // 新增：临时存储前5条数据
      tempLeftBrainData: [],
      tempRightBrainData: [],
      tempAllBrainData: [],

      // 左脑监测数据
      leftBrainLatestValue: 0, // 左脑当前最新的阻抗值
      leftBrainMaxValue: 0, // 左脑监测过程中的最大阻抗值

      // 右脑监测数据
      rightBrainLatestValue: 0, // 右脑当前最新的阻抗值
      rightBrainMaxValue: 0, // 右脑监测过程中的最大阻抗值

      // 全脑监测数据
      allBrainLatestValue: 0, // 全脑（左右脑平均）当前最新值
      allBrainMaxValue: 0, // 全脑监测过程中的最大值

      // 导航菜单配置
      navItems: [
        {
          src: require('@/image/monitor/StartMonitoring.png'),
          alt: '开始监测',
          disabled: false,
          show: true // 默认显示
        },
        {
          src: require('@/image/monitor/stop.png'),
          alt: '停止监测',
          disabled: false,
          show: false // 默认隐藏
        },
        {
          src: require('@/image/monitor/pause.png'),
          alt: '暂停监测',
          disabled: false,
          show: false // 默认隐藏
        },
        {
          src: require('@/image/monitor/ContinueMonitoring.png'),
          alt: '继续监测',
          disabled: true, // 默认禁用
          show: true // 默认显示
        },
        {
          src: require('@/image/monitor/Reporting.png'),
          alt: '生成报告',
          disabled: false,
          show: true // 默认显示
        },
        {
          src: require('@/image/monitor/DataPlayback.png'),
          alt: '数据回放',
          disabled: false,
          show: true // 默认显示
        },
        {
          src: require('@/image/monitor/InformationEditing.png'),
          alt: '编辑信息',
          disabled: false,
          show: true // 默认显示
        },
      ],

      playbackTimer: null, // 数据回放功能的定时器

      // 新增全脑稳定系数数组
      stabilityLeftBrain: [], // 存储左脑稳定系数
      stabilityRightBrain: [], // 存储右脑稳定系数
      stabilityAllBrain: [], // 存储颅内压
      stabilityWholeBrain: [], // 存储全脑稳定系数

      userCache: null, // 添加用户缓存

      // 时间显示相关
      startTime: null, // 开始监测的时间戳
      startTimeDisplay: '--:--:--', // 开始时间显示
      monitoringTime: 0, // 监测时间（秒）
      monitoringTimeDisplay: '00:00:00', // 监测时间显示
      monitoringTimer: null, // 监测时间计时器

      // 新增电极检测通过后的处理逻辑
      isFirstDataAfterDetection: true,
      preprocessedReportData: null, // 预处理的报告数据
      batteryLevel: 0, // 电量百分比
      bluetoothStatus: '未连接', // 蓝牙连接状态
    }
  },

  computed: {
    ...mapState(['userInfo', 'originalData', 'isConnected', 'currentPatient']),
  },

  methods: {
    ...mapMutations([
      'setUserInfo', // 设置用户信息
      'setDevices', // 设置设备列表
      'setBleId', // 设置蓝牙设备ID
      'setIsConnected', // 设置蓝牙连接状态
      'setOriginalData', // 设置原始数据
    ]),
    
    /**
     * 启动重连机制
     */
    startReconnection() {
      console.log('启动持续重连机制')
      // 初始化重连计数器，用于显示尝试次数
      this.reconnectCount = 0
      this.reconnectTimer = null
      
      // 启动重连循环
      this.tryReconnect()
    },
    
    /**
     * 尝试重新连接设备
     */
    tryReconnect() {
      this.reconnectCount++
      console.log(`正在尝试第 ${this.reconnectCount} 次重连...`)
      
      // 使用原有的连接方法尝试重连
      handleConnect()
        .then(() => {
          console.log('自动重连成功')
          this.isReconnecting = false
          
          // 重连成功，清除定时器
          if (this.reconnectTimer) {
            clearTimeout(this.reconnectTimer)
            this.reconnectTimer = null
          }

          setTimeout(() => {
            writeBLEState(17)
          }, 7000)
        })
        .catch(err => {
          console.error('自动重连失败:', err)
          
          // 无论如何都会继续尝试，5秒后再次尝试
          this.reconnectTimer = setTimeout(() => {
            this.tryReconnect()
          }, 5000) // 5秒后再次尝试
        })
    },

    /**
     * 检查接收到的数据格式是否正确，并进行相应处理
     * @param {ArrayBuffer} array - 接收到的原始数据
     */
    checkFormat(array) {
      let arrays = Array.prototype.slice.call(new Uint8Array(array))
      let myArr = []
      myArr.push(...arrays)
      let res = checkPackage(myArr)
      console.log('res', res)
      // 如果数据类型为0x06，则进行深度检测
      if (res[3] === 0x06) this.analyticDeepData(res)
      // 如果数据类型为0x10，则进行电量检测
      if (res[3] === 0x10) this.analyticBatteryData(res)
    },

    /**
     * 解析电量数据
     * @param {Array} array - 经过初步处理的数据数组
     */
    analyticBatteryData(array) {
      // 获取电量值
      let battery = array[4]
      console.log('电量:', battery)
      if(battery < 20){
        uni.showToast({
          title: '电量不足，请及时充电',
          icon: 'none',
          duration: 2000,
        })
      }
      
      // 更新电量值
      this.batteryLevel = battery
    },


    /**
     * 深度检测功能，处理阻抗数据并更新显示
     * @param {Array} array - 经过初步处理的数据数组
     */
    analyticDeepData(array) {
      // 解析数据前端部分
      let decode_front = array.slice(4, -3)
      // 获取左脑阻抗值，保留小数点后2位
      let fixL = parseFloat(convertFloat(decode_front.slice(0, 4).reverse()).toFixed(2))
      // 获取右脑阻抗值，保留小数点后2位
      let fixR = parseFloat(convertFloat(decode_front.slice(4, 8).reverse()).toFixed(2))
      
      console.log('左脑',fixL)
      console.log('右脑',fixR)
      // 如果左脑值为0但右脑值不为0，则使用右脑值作为左脑值
      if (fixL === 0 && fixR !== 0) {
        console.log('左脑值为0，使用右脑值替代：', fixR)
        fixL = fixR
      } else if (fixR === 0 && fixL !== 0) {
        // 如果右脑值为0但左脑值不为0，则使用左脑值作为右脑值
        console.log('右脑值为0，使用左脑值替代：', fixL)
        fixR = fixL
      }
      
      // 计算当前全脑平均值，保留小数点后2位
      const currentAverage = parseFloat(((fixL + fixR) / 2).toFixed(2))
      
      // 只在第一次检测时执行电极检测逻辑
      if (
        this.isFirstDetection &&
        impedanceL.length === 5 &&
        impedanceR.length === 5
      ) {
        // // 发送停止指令
        // writeBLEState(99)

        // 检查是否存在异常数据（大于1000的值）
        const hasAbnormalL = impedanceL.some((value) => value > 1000)
        const hasAbnormalR = impedanceR.some((value) => value > 1000)

        if (hasAbnormalL || hasAbnormalR) {
          console.log('检测到异常值，显示异常电极弹框')
          // 隐藏相关弹框
          this.showStartMonitoringDialog = false
          this.showElectrodeDetection = false
          // 显示异常电极弹框
          this.showAbnormalElectrode = true
          // 记录异常数据到图表
          impedanceAll.push(currentAverage)
          this.updateChart()
        } else {
          this.showElectrodeDetection = false
          toast('开始监测')
          // 如果没有检测到异常，发送开始监测指令
          // setTimeout(() => {
          //   writeBLEState(17)
          // }, 1500)

          // 清空前5条数据，保留有效数据
          impedanceL = []
          impedanceR = []
          impedanceAll = []
          
          // 重置第一个值，以便后续计算使用新的基准值
          this.leftBrainFirstValue = null
          this.rightBrainFirstValue = null
          this.allBrainFirstValue = null
          
          // 清空稳定系数数组
          this.stabilityLeftBrain = []
          this.stabilityRightBrain = []
          this.stabilityAllBrain = []
          this.stabilityWholeBrain = []
          
          // 设置标记，开始收集前5条数据
          this.isCollectingInitialData = true
          this.formalMonitoringDataCount = 0
          this.tempLeftBrainData = []
          this.tempRightBrainData = []
          this.tempAllBrainData = []
          
          // 更新图表数据
          this.updateChart()
          
          console.log('已清除电极检测数据，开始收集前5条正式监测数据')
        }

        // 标记第一次检测完成
        this.isFirstDetection = false
        return
      } 
      
      // 如果正在收集前5条数据
      if (this.isCollectingInitialData && !this.isFirstDetection) {
        console.log("进入了第一次")
        // 临时存储数据
        this.tempLeftBrainData.push(fixL)
        this.tempRightBrainData.push(fixR)
        this.tempAllBrainData.push(currentAverage)
        this.formalMonitoringDataCount++
        
        console.log(`收集初始数据: ${this.formalMonitoringDataCount}/5`)
        if (fixL > 1000 || fixR > 1000){
          // 隐藏相关弹框
          this.showStartMonitoringDialog = false
          this.showElectrodeDetection = false
          // 显示异常电极弹框
          this.showAbnormalElectrode = true
        }
        
        // 如果已经收集了5条数据
        if (this.formalMonitoringDataCount >= 5) {
          console.log('已收集5条初始数据，开始正式记录')
          
          // 使用第5条数据作为基准值
          this.leftBrainFirstValue = this.tempLeftBrainData[4]
          this.rightBrainFirstValue = this.tempRightBrainData[4]
          this.allBrainFirstValue = this.tempAllBrainData[4]
          
          // 清空临时数据和阻抗数组，准备正式记录
          impedanceL = []
          impedanceR = []
          impedanceAll = []
          
          // 将第5条数据作为第一条正式数据
          impedanceL.push(this.leftBrainFirstValue)
          impedanceR.push(this.rightBrainFirstValue)
          impedanceAll.push(this.allBrainFirstValue)
          
          // 将第一个稳定系数设置为0
          this.stabilityLeftBrain.push(0)
          this.stabilityRightBrain.push(0)
          this.stabilityWholeBrain.push(0)
          
          // 颅内压数据初始值 - 使用与计算公式一致的逻辑
          // 当全脑稳定系数为0时，颅内压为基准值200
          this.stabilityAllBrain.push(200)
          
          // 结束收集初始数据阶段
          this.isCollectingInitialData = false
          
          console.log('基准值设置为：', {
            leftBrain: this.leftBrainFirstValue,
            rightBrain: this.rightBrainFirstValue,
            allBrain: this.allBrainFirstValue
          })
          
          // 更新图表
          this.updateChart()
          return
        }
        
        // 如果还在收集前5条数据，不进行后续处理
        return
      }
      
      // 如果是第一次接收数据，保存左右脑和全脑初始值
      if (this.leftBrainFirstValue === null) {
        this.leftBrainFirstValue = fixL
      }
      
      if (this.rightBrainFirstValue === null) {
        this.rightBrainFirstValue = fixR
      }
      
      if (this.allBrainFirstValue === null) {
        this.allBrainFirstValue = currentAverage
      }

      // 更新阻抗数据数组
      impedanceL.push(fixL)
      impedanceR.push(fixR)
      impedanceAll.push(currentAverage)

      // 检查正常监测过程中的阻抗异常
      if (!this.isFirstDetection && (fixL > 1000 || fixR > 1000)) {
        console.log('正常监测中检测到异常值，显示异常电极弹框')
        this.showAbnormalElectrode = true
        // 记录异常数据到图表
        this.updateChart()
        // 发送停止指令
        writeBLEState(99)
      }

      if (this.isFirstDetection && (fixL > 1000 || fixR > 1000)){
        // 隐藏相关弹框
        this.showStartMonitoringDialog = false
        this.showElectrodeDetection = false
        // 显示异常电极弹框
        this.showAbnormalElectrode = true
        // 记录异常数据到图表
        this.updateChart()
      }

      // 更新左脑数据
      this.leftBrainLatestValue = parseFloat(this.leftBrainFirstValue ? Math.abs((fixL - this.leftBrainFirstValue) / this.leftBrainFirstValue * 100).toFixed(2) : 0)
      this.leftBrainMaxValue = parseFloat(Math.max(...impedanceL.map(value =>
        this.leftBrainFirstValue ? Math.abs((value - this.leftBrainFirstValue) / this.leftBrainFirstValue * 100) : 0
      )).toFixed(2))
      // 存储左脑稳定系数
      this.stabilityLeftBrain.push(this.leftBrainLatestValue)

      // 更新右脑数据
      this.rightBrainLatestValue = parseFloat(this.rightBrainFirstValue ? Math.abs((fixR - this.rightBrainFirstValue) / this.rightBrainFirstValue * 100).toFixed(2) : 0)
      this.rightBrainMaxValue = parseFloat(Math.max(...impedanceR.map(value =>
        this.rightBrainFirstValue ? Math.abs((value - this.rightBrainFirstValue) / this.rightBrainFirstValue * 100) : 0
      )).toFixed(2))
      // 存储右脑稳定系数
      this.stabilityRightBrain.push(this.rightBrainLatestValue)

      // 更新全脑稳定系数
      this.allBrainLatestValue = parseFloat(this.allBrainFirstValue ? Math.abs((currentAverage - this.allBrainFirstValue) / this.allBrainFirstValue * 100).toFixed(2) : 0)
      this.allBrainMaxValue = parseFloat(Math.max(...impedanceAll.map(value =>
        this.allBrainFirstValue ? Math.abs((value - this.allBrainFirstValue) / this.allBrainFirstValue * 100) : 0
      )).toFixed(2))

      // 存储全脑稳定系数
      this.stabilityWholeBrain.push(parseFloat(((this.leftBrainLatestValue + this.rightBrainLatestValue) / 2).toFixed(2)))
      
      // 存储颅内压数据 - 使用颅内压计算公式
      const baseValue = 200;
      const wholeBrainValue = parseFloat(((this.leftBrainLatestValue + this.rightBrainLatestValue) / 2).toFixed(2));
      const icpValue = baseValue - wholeBrainValue;
      // 确保颅内压数据不小于0
      const finalIcpValue = icpValue > 0 ? parseFloat(icpValue.toFixed(2)) : 0;
      this.stabilityAllBrain.push(finalIcpValue);
      
      console.log("当前的左脑",fixL)
      console.log("当前的右脑",fixR)
      console.log("左脑最大值", this.leftBrainMaxValue)
      console.log("右脑最大值", this.rightBrainMaxValue)
      console.log("颅内压数据数组长度", this.stabilityAllBrain.length)
      console.log("当前全脑稳定系数", wholeBrainValue)
      console.log("计算得到的颅内压值", finalIcpValue)

      // 非第一次检测时，直接更新图表
      this.updateChart()
    },

    // 更新图表数据
    updateChart() {
      // 获取图表实例
      const chart = this.$refs.chartRef
      if (chart) {

        // 更新x轴数据：如果实际数据量超过30，则使用实际数据量，否则固定30条
        const xAxisData = Array.from(
          { length: Math.max(30, impedanceL.length) },
          (_, i) => i
        )

        // 设置基准值，与报告页面保持一致
        const baseValue = 200
        
        // 创建颅内压数据数组，采用与报告页面相同的计算方式
        const chartData = []
        
        if (this.stabilityWholeBrain && this.stabilityWholeBrain.length > 0) {
          // 使用全脑稳定系数数据计算颅内压
          for (let i = 0; i < this.stabilityWholeBrain.length; i++) {
            const wholeBrainValue = this.stabilityWholeBrain[i]
            const icpValue = baseValue - wholeBrainValue
            chartData.push(icpValue > 0 ? parseFloat(icpValue.toFixed(2)) : 0)
          }
        } else if (impedanceL.length > 0 && impedanceR.length > 0) {
          // 如果没有stabilityWholeBrain，则基于左右脑稳定系数计算
          for (let i = 0; i < impedanceL.length; i++) {
            const leftStability = this.leftBrainFirstValue ? 
              Math.abs((impedanceL[i] - this.leftBrainFirstValue) / this.leftBrainFirstValue * 100) : 0
            const rightStability = this.rightBrainFirstValue ? 
              Math.abs((impedanceR[i] - this.rightBrainFirstValue) / this.rightBrainFirstValue * 100) : 0
            const wholeBrainValue = parseFloat(((leftStability + rightStability) / 2).toFixed(2))
            const icpValue = baseValue - wholeBrainValue
            chartData.push(icpValue > 0 ? parseFloat(icpValue.toFixed(2)) : 0)
          }
        } else {
          // 默认值
          chartData.push(200)
        }

        // 更新图表配置
        chart.setOption({
          xAxis: {
            data: xAxisData,
            // 确保x轴范围能够完整显示所有数据
            min: 0,
            max: Math.max(29, impedanceL.length - 1),
            // 其他x轴配置保持不变
          },
          yAxis: {
            type: 'value',
            scale: true, // 使用数值缩放以匹配报告页面
            min: function(value) {
              // 计算数据的平均值
              const avg = (value.max + value.min) / 2;
              // 计算数据范围
              const range = value.max - value.min;
              // 使用固定的放大系数，确保上下有足够空间
              return avg - range * 1.5;
            },
            max: function(value) {
              // 计算数据的平均值
              const avg = (value.max + value.min) / 2;
              // 计算数据范围
              const range = value.max - value.min;
              // 使用固定的放大系数，确保上下有足够空间
              return avg + range * 1.5;
            },
            axisLine: { show: false }, // 隐藏坐标轴线
            axisTick: { show: false }, // 隐藏刻度线
            axisLabel: { show: false }, // 隐藏刻度标签
          },
          series: [
            {
              data: chartData,
              type: 'line',
              lineStyle: {
                color: '#6DF7BE',
                width: 2,
              },
              symbol: 'none',
              smooth: true,
            },
          ],
        })
      }
    },

    async init() {
      try {
        // 等待图表实例初始化
        const chart = await this.$refs.chartRef.init(echarts)

        // 设置基准值，与报告页面保持一致
        const baseValue = 200
        
        // 创建颅内压数据数组，采用与报告页面相同的计算方式
        const chartData = []
        
        if (this.stabilityWholeBrain && this.stabilityWholeBrain.length > 0) {
          // 使用全脑稳定系数数据计算颅内压
          for (let i = 0; i < this.stabilityWholeBrain.length; i++) {
            const wholeBrainValue = this.stabilityWholeBrain[i]
            const icpValue = baseValue - wholeBrainValue
            chartData.push(icpValue > 0 ? parseFloat(icpValue.toFixed(2)) : 0)
          }
        } else if (impedanceL.length > 0 && impedanceR.length > 0) {
          // 如果没有stabilityWholeBrain，则基于左右脑稳定系数计算
          for (let i = 0; i < impedanceL.length; i++) {
            const leftStability = this.leftBrainFirstValue ? 
              Math.abs((impedanceL[i] - this.leftBrainFirstValue) / this.leftBrainFirstValue * 100) : 0
            const rightStability = this.rightBrainFirstValue ? 
              Math.abs((impedanceR[i] - this.rightBrainFirstValue) / this.rightBrainFirstValue * 100) : 0
            const wholeBrainValue = parseFloat(((leftStability + rightStability) / 2).toFixed(2))
            const icpValue = baseValue - wholeBrainValue
            chartData.push(icpValue > 0 ? parseFloat(icpValue.toFixed(2)) : 0)
          }
        } else {
          // 默认值
          chartData.push(200)
        }

        // 设置图表配置
        chart.setOption({
          grid: {
            top: '0%',
            left: '5%',
            right: '5%',
            bottom: '15%',
            containLabel: true,
            show: false,
            backgroundColor: 'transparent',
            borderColor: 'transparent',
          },
          xAxis: {
            type: 'category',
            boundaryGap: false,
            // 默认显示30条数据
            data: Array.from({ length: Math.max(30, impedanceL.length) }, (_, i) => i),
            // 确保x轴范围能够完整显示所有数据
            min: 0,
            max: Math.max(29, impedanceL.length - 1),
            axisLine: { show: false },
            axisTick: { show: false },
            axisLabel: { show: false },
            splitLine: {
              show: true,
              lineStyle: {
                color: 'rgba(255, 255, 255, 0.1)',
                type: 'solid',
                width: 1
              },
            },
          },
          yAxis: {
            type: 'value',
            scale: true, // 使用数值缩放以匹配报告页面
            min: function(value) {
              // 计算数据的平均值
              const avg = (value.max + value.min) / 2;
              // 计算数据范围
              const range = value.max - value.min;
              // 使用固定的放大系数，确保上下有足够空间
              return avg - range * 1.5;
            },
            max: function(value) {
              // 计算数据的平均值
              const avg = (value.max + value.min) / 2;
              // 计算数据范围
              const range = value.max - value.min;
              // 使用固定的放大系数，确保上下有足够空间
              return avg + range * 1.5;
            },
            axisLine: { show: false },
            axisTick: { show: false },
            axisLabel: { show: false },
            splitLine: {
              show: true,
              lineStyle: {
                color: 'rgba(255, 255, 255, 0.1)',
                type: 'solid',
                width: 1
              },
            },
          },
          series: [
            {
              data: chartData,
              type: 'line',
              lineStyle: {
                color: '#6DF7BE',
                width: 2,
              },
              symbol: 'none',
              smooth: true,
            },
          ],
          backgroundColor: 'transparent',
        })

        // 监听窗口变化，重绘图表
        window.addEventListener('resize', () => {
          chart.resize()
        })
      } catch (error) {
        console.error('图表初始化失败:', error)
      }
    },

    /**
     * 获取用户信息 - 优化版本
     * 1. 使用缓存机制避免重复读取
     * 2. 使用用户名作为键的对象结构加速查找
     */
    getUser() {
      // 如果缓存中已有该用户信息，直接返回
      if (this.userCache && this.userCache[this.username]) {
        const cachedUser = this.userCache[this.username]
        this.setUserInfo({ id: cachedUser.id, name: cachedUser.name })
        return
      }

      // 读取用户文件
      const users = readJsonFromFile('/sdcard/test/user.json') || []

      // 将用户数组转换为以用户名为键的对象，便于快速查找
      if (!this.userCache) {
        this.userCache = users.reduce((acc, user) => {
          acc[user.name] = user
          return acc
        }, {})
      }

      // 使用优化后的查找方式
      const user = this.userCache[this.username]
      if (user) {
        this.setUserInfo({ id: user.id, name: user.name })
      }
    },

    /**
     * 获取患者信息
     */
    getPatientInfo() {
      if (this.patientId) {
        // 1. 首先尝试从Vuex获取
        if (this.currentPatient && this.currentPatient.id === this.patientId) {
          this.patientInfo = this.currentPatient;
          console.log('从Vuex获取患者信息：', this.patientInfo);
          return;
        }

        // 2. 然后尝试从全局变量获取
        const app = getApp();
        if (app && app.globalData && app.globalData.currentPatient &&
          app.globalData.currentPatient.id === this.patientId) {
          this.patientInfo = app.globalData.currentPatient;
          console.log('从全局变量获取患者信息：', this.patientInfo);
          return;
        }

        // 3. 如果URL中包含fastMode参数，则跳过文件读取
        const pages = getCurrentPages();
        const currentPage = pages[pages.length - 1];
        if (currentPage && currentPage.$page && currentPage.$page.options &&
          currentPage.$page.options.fastMode === 'true') {
          console.log('快速模式，等待异步数据...');
          // 设置一个临时的患者信息，等待异步数据
          if (!this.patientInfo || !this.patientInfo.id) {
            this.patientInfo = { id: this.patientId, name: '加载中...' };
          }

          // 设置一个定时器，如果一段时间后还没有数据，则尝试从文件读取
          setTimeout(() => {
            if (!this.patientInfo || this.patientInfo.name === '加载中...') {
              console.log('快速模式超时，尝试从文件读取');
              this.loadPatientFromFile();
            }
          }, 1000);

          return;
        }

        // 4. 最后才从文件读取
        this.loadPatientFromFile();
      }
    },

    // 从文件加载患者信息
    loadPatientFromFile() {
      // 首先尝试从患者ID命名的文件中读取
      const patientReportFile = `/sdcard/test/${this.patientId}.json`;
      const patientReport = readJsonFromFile(patientReportFile);
      
      if (patientReport) {
        // 检查是否是数组
        if (Array.isArray(patientReport)) {
          console.log('患者报告文件包含多条记录，使用第一条记录')
          // 直接使用第一条记录
          this.patientInfo = patientReport[0];
        } else {
          // 如果不是数组，直接使用
          this.patientInfo = patientReport;
        }
        console.log('从患者报告文件获取患者信息：', this.patientInfo);
        return;
      }
      
      // 如果没有找到患者报告文件，尝试从旧的患者文件中读取
      const patients = readJsonFromFile('/sdcard/test/patient.json') || [];
      console.log('当前所有患者信息：', patients);
      const patient = patients.find((p) => p.id === this.patientId);
      if (patient) {
        this.patientInfo = patient;
        console.log('从旧文件获取患者信息：', patient);
        
        // 将患者信息保存到新的文件格式中
        this.migratePatientData(patient);
      }
    },
    
    // 迁移患者数据到新的文件格式
    migratePatientData(patient) {
      if (!patient || !patient.id) return;
      
      try {
        // 创建以患者ID命名的报告文件
        const patientReportFile = `/sdcard/test/${patient.id}.json`;
        const success = writeJsonToFile(patient, patientReportFile);

        if (success) {
          console.log('成功迁移患者数据到新文件格式');
          
          // 更新患者ID文件，确保ID一致性
          const patientIdsFile = '/sdcard/test/patient_ids.json';
          const idToSave = {
            id: patient.id // 使用患者对象中的ID，确保一致性
          };
          
          writeJsonToFile(idToSave, patientIdsFile);
          console.log('已将患者ID保存到patient_ids.json文件:', idToSave);
        }
      } catch (error) {
        console.error('迁移患者数据失败：', error);
      }
    },

    /**
     * 初始化用户信息
     */
    initUserInfo() {
      const userInfo = this.userInfo
      if (userInfo.account) {
        this.username = userInfo.account
        this.getUser()
      } else {
        this.username = uni.getStorageSync('account')
        if (this.username) {
          this.getUser()
        } else {
          console.log('No saved username found.')
          uni.reLaunch({ url: '/pages/index/index' })
        }
      }
    },

    handleNavClick(item) {
      console.log('点击了item', item)
      // 如果按钮被禁用，直接返回，不执行后续操作
      if (item.disabled) {
        console.log('按钮已禁用:', item.alt)
        return
      }

      console.log('点击了导航菜单：', item)
      if (item.alt === '开始监测') {
        // 判断蓝牙是否已连接
        if (this.isConnected) {
          console.log('蓝牙已连接，直接显示开始监测弹框')
          this.showStartMonitoringDialog = true
        } else {
          console.log('准备连接蓝牙设备')
          // 先尝试连接蓝牙设备
          handleConnect()
            .then(() => {
              // 等待蓝牙连接状态变化
              const checkConnection = setInterval(() => {
                if (this.isConnected) {
                  clearInterval(checkConnection)
                  console.log('蓝牙连接成功，显示开始监测弹框')
                  this.showStartMonitoringDialog = true
                }
              }, 2500)

              // 设置超时，如果10秒内没有连接成功，就停止等待
              setTimeout(() => {
                clearInterval(checkConnection)
                if (!this.isConnected) {
                  toast('蓝牙连接超时，请重试')
                }
              }, 10000)
            })
            .catch((error) => {
              console.error('蓝牙连接失败：', error)
              toast('蓝牙连接失败，请重试')
            })
        }
      }      
      if (item.alt === '停止监测') {
        writeBLEState(99)
        // 重置监测状态
        this.isMonitoring = false
        // 设置手动断开标志，防止自动重连
        this.isManualDisconnect = true
        console.log('用户点击停止监测按钮，设置手动断开标志，禁止自动重连')
        // 停止计时并重置
        this.stopTimer()
        // 更新按钮状态：启用开始监测、生成报告、数据回放、编辑信息按钮，禁用继续监测按钮
        this.navItems = this.navItems.map((item) => ({
          ...item,
          disabled: item.alt === '继续监测', // 只禁用继续监测按钮
          show: !['停止监测', '暂停监测'].includes(item.alt)
        }))
      }

      if (item.alt === '暂停监测') {
        writeBLEState(99)
        // 暂停计时
        this.pauseTimer()
        // 更新按钮状态：隐藏暂停监测，显示继续监测和停止监测，禁用其他按钮
        this.navItems = this.navItems.map((item) => ({
          ...item,
          disabled: !['继续监测', '停止监测'].includes(item.alt),
          show: ['继续监测', '停止监测'].includes(item.alt) || (!['暂停监测'].includes(item.alt) && item.show)
        }))
      }

      if (item.alt === '继续监测') {
        writeBLEState(17)
        // 继续计时
        this.resumeTimer()
        // 更新按钮状态：显示暂停监测和停止监测，隐藏继续监测和开始监测
        this.navItems = this.navItems.map((item) => ({
          ...item,
          disabled: !['停止监测', '暂停监测'].includes(item.alt),
          show: !['继续监测', '开始监测'].includes(item.alt) && (item.alt === '暂停监测' || item.alt === '停止监测' || item.show)
        }))
      }

      if (item.alt === '编辑信息') {
        console.log('当前 showEditDialog:', this.showEditDialog)
        
        // 检查是否已有患者ID
        if (!this.patientId && !this.patientInfo) {
          toast('请先输入患者基本信息')
          return
        }
        
        // 检查患者报告文件是否存在
        const patientReportFile = this.patientId ? `/sdcard/test/${this.patientId}.json` : null
        const patientReportExists = patientReportFile ? readJsonFromFile(patientReportFile) : null
        
        // 设置一个标记，传递给EditInformation组件，指示是否需要更新文件
        if (this.patientInfo) {
          this.patientInfo.shouldUpdateFile = !!patientReportExists
        }
        
        console.log('患者报告文件是否存在:', !!patientReportExists)
        console.log('编辑时是否需要更新文件:', this.patientInfo ? this.patientInfo.shouldUpdateFile : false)
        
        this.showEditDialog = true
        console.log('设置后 showEditDialog:', this.showEditDialog)
      }

      if (item.alt === '生成报告') {
        this.handleGenerateReport()
      }

      if (item.alt === '数据回放') {
        this.showDataPlaybackDialog = true
      }
    },

    handleMenuItemClick(option) {
      console.log('点击了选项：', option)
      if (option === '账号管理') {
        this.showAccountManagement = true
      }
      if (option === '资料中心') {
        this.showDataCenter = true
      }
      if (option === '修改密码') {
        this.showChangePassword = true
      }
      if (option === '退出登录') {
        this.showExitConfirm = true
      }
    },

    handleUpdateSuccess() {
      console.log('患者信息更新成功，重新获取患者信息')
      
      // 如果patientInfo中有shouldUpdateFile标记，表示已经在EditInformation组件中更新了信息
      if (this.patientInfo && this.patientInfo.shouldUpdateFile !== undefined) {
        // 删除临时标记
        delete this.patientInfo.shouldUpdateFile
        console.log('使用已更新的患者信息:', this.patientInfo)
      } else {
        // 重新获取患者信息
        this.getPatientInfo()
      }
    },

    // 处理开始监测按钮点击事件
    handleStartMonitoring() {
      // 检查是否是从数据回放来的数据，或者有fromDataPlayback标记
      if ((this.patientInfo && this.patientInfo.leftBrainImpedance && this.patientInfo.leftBrainImpedance.length > 0) || 
          (this.patientInfo && this.patientInfo.fromDataPlayback)) {
        console.log('检测到数据回放的数据或fromDataPlayback标记，准备创建新记录')
        
        // 生成新的患者ID
        const patientId = new Date().getTime().toString();
        
        // 创建新的患者数据，保持基本信息，生成新ID
        const newPatientData = {
          id: patientId,
          name: this.patientInfo.name,
          age: this.patientInfo.age || '',
          sex: this.patientInfo.sex || '',
          admissionNumber: this.patientInfo.admissionNumber || '',
          Department: this.patientInfo.Department || '',
          diagnosis: this.patientInfo.diagnosis || '',
          operator: this.username || '',
          createTime: new Date().toISOString(),
          leftBrainImpedance: [],
          rightBrainImpedance: [],
          allBrainImpedance: [],
        }


          // 更新当前患者信息为新创建的记录
          this.patientInfo = newPatientData;
          this.patientId = patientId;
          console.log('新创建的患者记录：', newPatientData);

      } else if (this.patientInfo && !this.patientId) {
        // 如果有患者信息但没有患者ID，说明是从编辑信息后开始监测
        console.log('从编辑信息后开始监测，创建新的患者记录');
        
        // 生成新的患者ID
        const patientId = new Date().getTime().toString();
        
        // 使用当前患者信息创建新记录
        const newPatientData = {
          ...this.patientInfo,
          id: patientId,
          operator: this.username || '',
          createTime: new Date().toISOString(),
          leftBrainImpedance: [],
          rightBrainImpedance: [],
          allBrainImpedance: [],
        };
        
        try {
          // 1. 首先创建/更新患者ID文件
          const patientIdsFile = '/sdcard/test/patient_ids.json';
          const idToSave = { id: patientId };
          const success1 = writeJsonToFile(idToSave, patientIdsFile);
          
          if (!success1) {
            toast('创建患者记录失败');
            return;
          }
          
          // 2. 创建以患者ID命名的报告文件
          const patientReportFile = `/sdcard/test/${patientId}.json`;
          const success2 = writeJsonToFile(newPatientData, patientReportFile);
          
          if (!success2) {
            console.error('创建患者报告文件失败');
            toast('创建患者记录失败');
            return;
          }
          
          // 更新当前患者信息和ID
          this.patientInfo = newPatientData;
          this.patientId = patientId;
          console.log('新创建的患者记录：', newPatientData);
        } catch (error) {
          console.error('创建数据失败：', error);
          toast('创建数据失败');
          return;
        }
      } else {
        console.log('使用当前患者信息开始监测:', this.patientInfo ? this.patientInfo.id : '无患者ID');
      }

      // 清空稳定系数数组
      this.stabilityLeftBrain = []
      this.stabilityRightBrain = []
      this.stabilityAllBrain = []
      this.stabilityWholeBrain = []

      // 设置监测状态为true
      this.isMonitoring = true

      // 更新按钮状态：只能点击停止监测和暂停监测
      this.navItems = this.navItems.map((item) => ({
        ...item,
        disabled: !['停止监测', '暂停监测'].includes(item.alt),
        show: item.alt === '停止监测' || item.alt === '暂停监测' || (!['开始监测', '继续监测'].includes(item.alt) && item.show)
      }))

      // 重置为第一次检测状态
      this.isFirstDetection = true
      // 清空所有阻抗数组数据
      impedanceL = []
      impedanceR = []
      impedanceAll = []
      // 重置左右脑和全脑第一个值
      this.leftBrainFirstValue = null
      this.rightBrainFirstValue = null
      this.allBrainFirstValue = null
      
      // 重置数据收集相关变量
      this.isCollectingInitialData = false
      this.formalMonitoringDataCount = 0
      this.tempLeftBrainData = []
      this.tempRightBrainData = []
      this.tempAllBrainData = []
      
      // 显示电极检测弹窗
      this.showElectrodeDetection = true

      // 设置开始时间并启动计时器
      this.startTimer()

      // 关闭开始监测对话框
      this.showStartMonitoringDialog = false
    },    
    // 处理异常电极情况
    handleAbnormalElectrode() {
      console.log('处理异常电极')
      this.showAbnormalElectrode = false
      // 重置监测状态
      this.isMonitoring = false
      
      // 重置开始时间和监测时间
      this.startTime = null
      this.monitoringTime = 0
      this.formattedTime = '00:00:00'
      
      // 停止计时器
      if (this.timer) {
        clearInterval(this.timer)
        this.timer = null
      }

      // 更新按钮状态：显示开始监测、数据回放、编辑信息按钮，禁用继续监测按钮
      this.navItems = this.navItems.map((item) => ({
        ...item,
        disabled: item.alt === '继续监测', // 只禁用继续监测按钮
        show: !['停止监测', '暂停监测'].includes(item.alt)
      }))
    },

    // 处理生成报告 - 优化版本
    async handleGenerateReport() {
      // 1. 验证数据完整性
      if (!this.stabilityLeftBrain.length || !this.stabilityRightBrain.length || 
          !this.stabilityAllBrain.length || !this.stabilityWholeBrain.length) {
        console.error('监测数据不完整')
        toast('监测数据不完整，请先完成监测')
        return
      }

      if (!this.patientId) {
        console.error('患者ID不存在')
        toast('患者信息不完整，无法生成报告')
        return
      }

      console.log('开始生成报告，patientId:', this.patientId)
      
      try {
        // 2. 停止监测相关操作
        writeBLEState(99) // 发送停止指令
        this.isMonitoring = false // 重置监测状态
        this.pauseTimer() // 暂停计时

        // 3. 显示加载提示
        uni.showLoading({
          title: '正在生成报告...',
          mask: true
        });
        
        // 4. 预处理数据 - 在主线程中完成轻量级操作
        // 准备更新的数据，使用稳定系数数组，过滤前5条数据
        const monitoringData = {
          leftBrainImpedance: this.stabilityLeftBrain,
          rightBrainImpedance: this.stabilityRightBrain,
          allBrainImpedance: this.stabilityAllBrain,
          stabilityWholeBrain: this.stabilityWholeBrain
        };

        console.log('更新数据:', {
          leftLength: monitoringData.leftBrainImpedance.length,
          rightLength: monitoringData.rightBrainImpedance.length,
          allBrainLength: monitoringData.allBrainImpedance.length,
          stabilityWholeBrainLength: monitoringData.stabilityWholeBrain.length,
          allBrainSample: monitoringData.allBrainImpedance.slice(0, 5),
          // 添加更多颅内压相关数据用于调试
          icpFirstValues: monitoringData.allBrainImpedance.slice(0, 5),
          wholeBrainFirstValues: monitoringData.stabilityWholeBrain.slice(0, 5),
          icpVerification: monitoringData.stabilityWholeBrain.slice(0, 5).map(v => v ? (200 - v) : 0)
        });
        
        // 5. 准备患者基本信息
        // 使用当前已有的患者信息，避免额外的文件读取
        const patientBaseInfo = this.patientInfo || {};
        
        // 6. 合并患者信息和监测数据
        const updatedReport = {
          ...patientBaseInfo,
          id: this.patientId,
          name: patientBaseInfo.name || '未知患者',
          age: patientBaseInfo.age || '',
          sex: patientBaseInfo.sex || '',
          admissionNumber: patientBaseInfo.admissionNumber || '',
          Department: patientBaseInfo.Department || '',
          diagnosis: patientBaseInfo.diagnosis || '',
          operator: this.username || '',
          leftBrainImpedance: monitoringData.leftBrainImpedance,
          rightBrainImpedance: monitoringData.rightBrainImpedance,
          allBrainImpedance: monitoringData.allBrainImpedance,
          stabilityWholeBrain: monitoringData.stabilityWholeBrain,
          updateTime: new Date().toISOString()
        };
        
        // 7. 异步执行文件写入操作
        const writeSuccess = await this.writeReportDataAsync(updatedReport);
        
        if (writeSuccess) {
          // 8. 更新当前患者信息
          this.patientInfo = updatedReport;
          
          // 9. 预处理报告数据 - 新增
          await this.preprocessReportData(updatedReport);
          
          // 10. 隐藏加载提示并显示成功消息
          uni.hideLoading();
          toast('报告生成成功');
          
          // 11. 显示报告弹框
          this.showReportDialog = true;
        } else {
          uni.hideLoading();
          toast('报告生成失败');
        }
      } catch (error) {
        uni.hideLoading();
        console.error('生成报告时发生错误:', error);
        toast('生成报告时发生错误');
      }
    },
    
    // 异步写入报告数据
    async writeReportDataAsync(reportData) {
      return new Promise(resolve => {
        // 使用setTimeout替代requestAnimationFrame，确保UI更新后再执行耗时操作
        setTimeout(() => {
          try {
            // 1. 写入患者报告文件
            const patientReportFile = `/sdcard/test/${reportData.id}.json`;
            console.log('写入报告文件:', patientReportFile);
            
            const success1 = writeJsonToFile(
              reportData,
              patientReportFile,
              true // 使用替换模式
            );
            
            if (!success1) {
              console.error('写入患者报告文件失败');
              resolve(false);
              return;
            }
            
            // 2. 更新患者ID文件 - 只在必要时执行
            this.updatePatientIdFile(reportData.id)
              .then(() => {
                resolve(true);
              })
              .catch(error => {
                console.error('更新患者ID文件失败:', error);
                // 即使患者ID文件更新失败，也认为报告生成成功
                resolve(true);
              });
          } catch (error) {
            console.error('写入报告数据失败:', error);
            resolve(false);
          }
        }, 0); // 使用0毫秒延迟，让它在当前事件循环结束后执行
      });
    },
    
    // 更新患者ID文件 - 只在必要时执行
    async updatePatientIdFile(patientId) {
      return new Promise((resolve, reject) => {
        try {
          const patientIdsFile = '/sdcard/test/patient_ids.json';
          
          // 使用缓存机制避免重复读取
          if (!this._patientIdsCache) {
            const patientIdsData = readJsonFromFile(patientIdsFile) || [];
            this._patientIdsCache = Array.isArray(patientIdsData) ? patientIdsData : [patientIdsData];
          }
          
          // 检查是否已存在该患者ID
          const existingIndex = this._patientIdsCache.findIndex(item => item && item.id === patientId);
          
          if (existingIndex === -1) {
            // 如果不存在，添加新的患者ID
            const idToSave = { id: patientId };
            this._patientIdsCache.push(idToSave);
            
            // 写入文件
            const success = writeJsonToFile(this._patientIdsCache, patientIdsFile, true);
            
            if (success) {
              console.log('已将患者ID保存到patient_ids.json文件');
              resolve(true);
            } else {
              reject(new Error('写入患者ID文件失败'));
            }
          } else {
            // 已存在，无需更新
            resolve(true);
          }
        } catch (error) {
          reject(error);
        }
      });
    },

    // 异步获取患者信息
    async getPatientInfoAsync() {
      return new Promise(resolve => {
        setTimeout(() => {
          try {
            // 首先尝试从患者ID命名的文件中读取
            const patientReportFile = `/sdcard/test/${this.patientId}.json`;
            const patientReport = readJsonFromFile(patientReportFile);
            
            if (patientReport) {
              // 如果是数组，取第一个元素
              const patientInfo = Array.isArray(patientReport) ? patientReport[0] : patientReport;
              resolve(patientInfo);
              return;
            }
            
            // 如果没有找到患者报告文件，尝试从旧的患者文件中读取
            const stabilityData = readJsonFromFile('/sdcard/test/stability_data.json') || [];
            // 获取该患者的最新一条监测数据
            const latestStabilityData = stabilityData
              .filter(data => data.patientId === this.patientId)
              .sort((a, b) => new Date(b.createData) - new Date(a.createData))[0];
            resolve(latestStabilityData);
          } catch (error) {
            console.error('获取患者信息失败:', error);
            resolve(null);
          }
        }, 0);
      });
    },

    // 处理报告弹框关闭
    handleReportClose() {
      this.showReportDialog = false
      // 清空预处理数据，释放内存
      this.preprocessedReportData = null
      
      // 添加fromDataPlayback标记，确保下次点击开始监测时创建新记录
      if (this.patientInfo) {
        this.patientInfo.fromDataPlayback = true;
        console.log('报告弹框关闭，添加fromDataPlayback标记');
      }
    },

    /**
     * 关闭修改密码弹框
     */
    handleCloseChangePassword() {
      this.showChangePassword = false
    },

    /**
     * 处理密码修改成功
     */
    handlePasswordChangeSuccess() {
      console.log('密码修改成功')
    },

    /**
     * 关闭账号管理弹框
     */
    handleCloseAccountManagement() {
      this.showAccountManagement = false
    },

    /**
     * 关闭资料中心弹框
     */
    handleCloseDataCenter() {
      this.showDataCenter = false
    },

    /**
     * 处理数据回放
     */
    handleDataPlayback(patientData) {
      console.log('数据回放：', patientData)
      
      // 更新患者信息
      this.patientInfo = patientData
      this.patientId = patientData.id

      // 重置阻抗数组和显示值
      impedanceL = []
      impedanceR = []
      impedanceAll = []
      this.leftBrainLatestValue = 0
      this.rightBrainLatestValue = 0
      this.allBrainLatestValue = 0
      this.leftBrainMaxValue = 0
      this.rightBrainMaxValue = 0
      this.allBrainMaxValue = 0

      // 检查数据是否存在且是数组
      if (
        Array.isArray(patientData.leftBrainImpedance) &&
        Array.isArray(patientData.rightBrainImpedance) &&
        Array.isArray(patientData.allBrainImpedance) &&
        Array.isArray(patientData.stabilityWholeBrain) &&
        patientData.leftBrainImpedance.length > 0 &&
        patientData.rightBrainImpedance.length > 0 &&
        patientData.allBrainImpedance.length > 0 &&
        patientData.stabilityWholeBrain.length > 0
      ) {
        console.log('数据验证通过，开始回放')

        // 禁用部分按钮
        this.navItems = this.navItems.map((item) => ({
          ...item,
          disabled: ['开始监测', '继续监测', '生成报告', '数据回放','编辑信息'].includes(
            item.alt
          ),
        }))

        console.log('navitem', this.navItems)

        // 获取数据长度
        const dataLength = patientData.leftBrainImpedance.length
        console.log('数据长度：', dataLength)
        let currentIndex = 0

        // 先清除可能存在的定时器
        if (this.playbackTimer) {
          clearTimeout(this.playbackTimer)
          this.playbackTimer = null
        }

        // 定义更新函数
        const updateData = () => {
          console.log(
            '定时器执行，currentIndex:',
            currentIndex,
            '总长度:',
            dataLength
          )

          if (currentIndex >= dataLength) {
            console.log('回放完成，清除定时器')
            // 恢复所有按钮状态
            this.navItems = this.navItems.map((item) => ({
              ...item,
              disabled: false,
            }))
            if (this.playbackTimer) {
              clearTimeout(this.playbackTimer)
              this.playbackTimer = null
            }
            return
          }

          // 添加左脑数据
          const leftValue = parseFloat(patientData.leftBrainImpedance[currentIndex])
          console.log('添加左脑数据：', leftValue)
          impedanceL.push(leftValue)

          // 添加右脑数据
          const rightValue = parseFloat(patientData.rightBrainImpedance[currentIndex])
          console.log('添加右脑数据：', rightValue)
          impedanceR.push(rightValue)

          // 添加全脑数据
          // 兼容新旧数据格式，优先使用stabilityWholeBrain，如果不存在则使用allBrainImpedance
          const allValue = parseFloat(
            patientData.stabilityWholeBrain && patientData.stabilityWholeBrain[currentIndex] !== undefined
              ? patientData.stabilityWholeBrain[currentIndex]
              : patientData.allBrainImpedance[currentIndex] || 0
          )
          console.log('添加全脑数据：', allValue)
          impedanceAll.push(allValue)

          // 更新显示的值
          this.leftBrainLatestValue = parseFloat(leftValue.toFixed(2))
          this.leftBrainMaxValue = parseFloat(Math.max(...impedanceL).toFixed(2))
          this.rightBrainLatestValue = parseFloat(rightValue.toFixed(2))
          this.rightBrainMaxValue = parseFloat(Math.max(...impedanceR).toFixed(2))
          this.allBrainLatestValue = parseFloat(allValue.toFixed(2))
          this.allBrainMaxValue = parseFloat(Math.max(...impedanceAll).toFixed(2))

          // 计算颅内压数据 - 修改为使用与报告页面相同的计算逻辑
          const baseValue = 200 // 与报告页面使用相同的基准值
          
          // 优先使用stabilityWholeBrain数据计算颅内压
          let intracranialPressure = 0
          if (patientData.stabilityWholeBrain && patientData.stabilityWholeBrain[currentIndex] !== undefined) {
            const wholeBrainValue = parseFloat(patientData.stabilityWholeBrain[currentIndex]);
            // 确保wholeBrainValue是有效的数值
            if (!isNaN(wholeBrainValue)) {
              intracranialPressure = baseValue - wholeBrainValue;
              intracranialPressure = intracranialPressure > 0 ? parseFloat(intracranialPressure.toFixed(2)) : 0;
            } else {
              // 如果当前值无效，尝试使用前一个有效值
              if (currentIndex > 0 && patientData.stabilityWholeBrain[currentIndex - 1] !== undefined) {
                const prevValue = parseFloat(patientData.stabilityWholeBrain[currentIndex - 1]);
                intracranialPressure = baseValue - prevValue;
                intracranialPressure = intracranialPressure > 0 ? parseFloat(intracranialPressure.toFixed(2)) : 0;
              }
            }
          } else {
            // 如果没有stabilityWholeBrain数据，则使用左右脑稳定系数的平均值
            const leftStability = parseFloat(patientData.leftBrainImpedance[currentIndex]);
            const rightStability = parseFloat(patientData.rightBrainImpedance[currentIndex]);
            
            // 确保左右脑数据都是有效的数值
            if (!isNaN(leftStability) && !isNaN(rightStability)) {
              const wholeBrainValue = (leftStability + rightStability) / 2;
              intracranialPressure = baseValue - wholeBrainValue;
              intracranialPressure = intracranialPressure > 0 ? parseFloat(intracranialPressure.toFixed(2)) : 0;
            } else {
              // 如果当前值无效，尝试使用前一个有效值
              if (currentIndex > 0) {
                const prevLeftStability = parseFloat(patientData.leftBrainImpedance[currentIndex - 1]);
                const prevRightStability = parseFloat(patientData.rightBrainImpedance[currentIndex - 1]);
                if (!isNaN(prevLeftStability) && !isNaN(prevRightStability)) {
                  const prevWholeBrainValue = (prevLeftStability + prevRightStability) / 2;
                  intracranialPressure = baseValue - prevWholeBrainValue;
                  intracranialPressure = intracranialPressure > 0 ? parseFloat(intracranialPressure.toFixed(2)) : 0;
                }
              }
            }
          }
          
          console.log('计算颅内压数据：', intracranialPressure)

          // 更新图表
          this.$nextTick(() => {
            const chart = this.$refs.chartRef
            if (chart) {
              console.log('更新图表，当前数据：', intracranialPressure)
              
              // 创建颅内压数据数组 - 使用与报告页面相同的计算逻辑
              const pressureArray = []
              let lastValidValue = null;
              
              for (let i = 0; i <= currentIndex; i++) {
                let value = null;
                
                // 优先使用stabilityWholeBrain数据
                if (patientData.stabilityWholeBrain && patientData.stabilityWholeBrain[i] !== undefined) {
                  const wholeBrainValue = parseFloat(patientData.stabilityWholeBrain[i]);
                  
                  if (!isNaN(wholeBrainValue)) {
                    value = baseValue - wholeBrainValue;
                    value = value > 0 ? parseFloat(value.toFixed(2)) : 0;
                    lastValidValue = value; // 更新最后的有效值
                  } else if (lastValidValue !== null) {
                    value = lastValidValue; // 使用最后的有效值
                  } else {
                    value = 0; // 如果没有有效值，默认为0
                  }
                } else {
                  // 如果没有stabilityWholeBrain数据，则使用左右脑稳定系数的平均值
                  const leftStability = parseFloat(patientData.leftBrainImpedance[i]);
                  const rightStability = parseFloat(patientData.rightBrainImpedance[i]);
                  
                  if (!isNaN(leftStability) && !isNaN(rightStability)) {
                    const wholeBrainValue = (leftStability + rightStability) / 2;
                    value = baseValue - wholeBrainValue;
                    value = value > 0 ? parseFloat(value.toFixed(2)) : 0;
                    lastValidValue = value; // 更新最后的有效值
                  } else if (lastValidValue !== null) {
                    value = lastValidValue; // 使用最后的有效值
                  } else {
                    value = 0; // 如果没有有效值，默认为0
                  }
                }
                
                pressureArray.push(value);
              }
              
              // 确保数组末尾没有异常值
              if (pressureArray.length > 0) {
                const lastFewValues = pressureArray.slice(-3);
                const validValues = lastFewValues.filter(v => v !== null && !isNaN(v));
                
                if (validValues.length > 0) {
                  const avgValue = validValues.reduce((a, b) => a + b, 0) / validValues.length;
                  
                  // 如果最后一个值与平均值相差过大，可能是异常值，用前一个值替代
                  const lastValue = pressureArray[pressureArray.length - 1];
                  if (Math.abs(lastValue - avgValue) > avgValue * 0.5) {
                    pressureArray[pressureArray.length - 1] = pressureArray.length > 1 ? 
                      pressureArray[pressureArray.length - 2] : avgValue;
                  }
                }
              }
              
              // 更新图表配置
              chart.setOption({
                xAxis: {
                  type: 'category',
                  boundaryGap: false,
                  data: Array.from({ length: dataLength }, (_, i) => i + 1),
                  // 确保x轴范围能够完整显示所有数据
                  min: 0,
                  max: Math.max(29, dataLength - 1),
                  axisLine: { show: false },
                  axisTick: { show: false },
                  axisLabel: { show: false },
                  splitLine: {
                    show: true,
                    lineStyle: {
                      color: 'rgba(255, 255, 255, 0.1)',
                      type: 'solid',
                      width: 1,
                    },
                  },
                },
                yAxis: {
                  type: 'value',
                  min: function(value) {
                    // 计算数据的平均值
                    const avg = (value.max + value.min) / 2;
                    // 计算数据范围
                    const range = value.max - value.min;
                    // 使用固定的放大系数，确保上下有足够空间
                    return avg - range * 1.5;
                  },
                  max: function(value) {
                    // 计算数据的平均值
                    const avg = (value.max + value.min) / 2;
                    // 计算数据范围
                    const range = value.max - value.min;
                    // 使用固定的放大系数，确保上下有足够空间
                    return avg + range * 1.5;
                  },
                  axisLine: { show: false }, // 隐藏坐标轴线
                  axisTick: { show: false }, // 隐藏刻度线
                  axisLabel: { show: false }, // 隐藏刻度标签
                  lineStyle: {
                    color: 'rgba(255, 255, 255, 0.1)',
                    type: 'solid',
                    width: 1,
                  },
                },                
                series: [
                  {
                    data: Array.isArray(pressureArray[0]) ? pressureArray : pressureArray.slice(0, currentIndex + 1),
                    type: 'line',
                    lineStyle: {
                      color: '#6DF7BE',
                      width: 2,
                    },
                    symbol: 'none',
                    smooth: true,
                    // 防止曲线在结束点异常下降
                    connectNulls: true,
                  },
                ],
                grid: {
                  top: '0%',
                  left: '5%',
                  right: '5%',
                  bottom: '15%',
                  containLabel: true,
                  show: false,
                  backgroundColor: 'transparent',
                  borderColor: 'transparent',
                },
                backgroundColor: 'transparent',
              })
            }
          })

          currentIndex++

          // 继续执行下一次更新
          this.playbackTimer = setTimeout(updateData, 300)
        }

        // 开始第一次更新
        console.log('开始执行更新函数')
        // 确保之前的定时器已清除
        if (this.playbackTimer) {
          clearTimeout(this.playbackTimer)
        }
        this.playbackTimer = setTimeout(updateData, 0)
      } else {
        console.log('数据验证失败：', {
          leftBrainExists: Array.isArray(patientData.leftBrainImpedance),
          rightBrainExists: Array.isArray(patientData.rightBrainImpedance),
          allBrainExists: Array.isArray(patientData.allBrainImpedance),
          stabilityWholeBrainExists: Array.isArray(patientData.stabilityWholeBrain),
        })
        toast('该记录脑电数据不完整，无法回放')
      }
    },

    /**
     * 关闭数据回放弹框
     */
    handleCloseDataPlayback() {
      // 清除回放定时器
      if (this.playbackTimer) {
        clearTimeout(this.playbackTimer)
        this.playbackTimer = null
      }

      this.showDataPlaybackDialog = false

      // 重置所有状态
      impedanceL = []
      impedanceR = []
      impedanceAll = []
      // 重置左右脑和全脑第一个值
      this.leftBrainFirstValue = null
      this.rightBrainFirstValue = null
      this.allBrainFirstValue = null

      // 重置显示的值
      this.leftBrainLatestValue = 0
      this.leftBrainMaxValue = 0
      this.rightBrainLatestValue = 0
      this.rightBrainMaxValue = 0
      this.allBrainLatestValue = 0
      this.allBrainMaxValue = 0

      // 更新图表，清空数据
      this.updateChart()

      // 重置稳定系数数组
      this.stabilityLeftBrain = []
      this.stabilityRightBrain = []
      this.stabilityAllBrain = []
      this.stabilityWholeBrain = []

      // 重置开始时间显示
      this.startTimeDisplay = '--:--:--'
      
      // 清除patientInfo中的监测数据，防止开始监测时误判为数据回放
      if (this.patientInfo) {
        // 保存基本信息
        const basicInfo = {
          id: this.patientInfo.id,
          name: this.patientInfo.name,
          age: this.patientInfo.age,
          sex: this.patientInfo.sex,
          admissionNumber: this.patientInfo.admissionNumber,
          Department: this.patientInfo.Department,
          diagnosis: this.patientInfo.diagnosis,
          operator: this.patientInfo.operator,
          // 添加一个标记，表示这是从数据回放来的
          fromDataPlayback: true
        };
        
        // 重置patientInfo，只保留基本信息
        this.patientInfo = basicInfo;
        
        console.log('数据回放关闭，已清除监测数据，保留基本信息:', basicInfo);
      }
    },

    /**
     * 取消退出操作
     */
    handleCancelExit() {
      this.showExitConfirm = false
      writeBLEState(99)
    },

    /**
     * 确认退出并跳转到登录页
     */
    handleConfirmExit() {
      uni.reLaunch({
        url: '/pages/index/index',
      })
    },


    /**
     * 格式化时间为 HH:MM:SS 格式
     * @param {Date} date - 日期对象
     * @returns {string} 格式化后的时间字符串
     */
    formatTime(date) {
      if (!date) return '--:--:--'
      const hours = date.getHours().toString().padStart(2, '0')
      const minutes = date.getMinutes().toString().padStart(2, '0')
      const seconds = date.getSeconds().toString().padStart(2, '0')
      return `${hours}:${minutes}:${seconds}`
    },

    /**
     * 格式化秒数为 HH:MM:SS 格式
     * @param {number} seconds - 秒数
     * @returns {string} 格式化后的时间字符串
     */
    formatSeconds(seconds) {
      const hours = Math.floor(seconds / 3600).toString().padStart(2, '0')
      const minutes = Math.floor((seconds % 3600) / 60).toString().padStart(2, '0')
      const secs = Math.floor(seconds % 60).toString().padStart(2, '0')
      return `${hours}:${minutes}:${secs}`
    },

    /**
     * 开始计时
     */
    startTimer() {
      // 清除可能存在的计时器
      if (this.monitoringTimer) {
        clearInterval(this.monitoringTimer)
        this.monitoringTimer = null
      }

      // 设置开始时间
      const now = new Date()
      this.startTime = now
      this.startTimeDisplay = this.formatTime(now)

      // 启动计时器，每秒更新一次
      this.monitoringTimer = setInterval(() => {
        this.monitoringTime++
        this.monitoringTimeDisplay = this.formatSeconds(this.monitoringTime)
      }, 1000)
    },

    /**
     * 暂停计时
     */
    pauseTimer() {
      if (this.monitoringTimer) {
        clearInterval(this.monitoringTimer)
        this.monitoringTimer = null
      }
    },

    /**
     * 停止计时
     */
    stopTimer() {
      if (this.monitoringTimer) {
        clearInterval(this.monitoringTimer)
        this.monitoringTimer = null
      }
      this.monitoringTime = 0
      this.monitoringTimeDisplay = '00:00:00'
    },

    /**
     * 继续计时
     */
    resumeTimer() {
      if (!this.monitoringTimer) {
        this.monitoringTimer = setInterval(() => {
          this.monitoringTime++
          this.monitoringTimeDisplay = this.formatSeconds(this.monitoringTime)
        }, 1000)
      }
    },

    handleHomeClick() {
      // 清除数据回放定时器
      if (this.playbackTimer) {
        console.log('清除数据回放定时器');
        clearTimeout(this.playbackTimer);
        this.playbackTimer = null;
      }

      // 如果正在显示数据回放弹框，关闭它
      if (this.showDataPlaybackDialog) {
        this.handleCloseDataPlayback();
      } else {
        // 即使没有显示数据回放弹框，也清除patientInfo中的监测数据
        if (this.patientInfo && (this.patientInfo.leftBrainImpedance || this.patientInfo.rightBrainImpedance || this.patientInfo.allBrainImpedance)) {
          // 保存基本信息
          const basicInfo = {
            id: this.patientInfo.id,
            name: this.patientInfo.name,
            age: this.patientInfo.age,
            sex: this.patientInfo.sex,
            admissionNumber: this.patientInfo.admissionNumber,
            Department: this.patientInfo.Department,
            diagnosis: this.patientInfo.diagnosis,
            operator: this.patientInfo.operator,
            // 添加一个标记，表示这是从数据回放来的
            fromDataPlayback: true
          };
          
          // 重置patientInfo，只保留基本信息
          this.patientInfo = basicInfo;
          
          console.log('点击首页按钮，已清除监测数据，保留基本信息:', basicInfo);
        }
      }
    },

    // 异步获取最新的稳定性数据 - 这个方法在新的文件格式下不再需要，但保留以兼容旧代码
    async getLatestStabilityDataAsync() {
      return new Promise(resolve => {
        setTimeout(() => {
          try {
            // 首先尝试从患者ID命名的文件中读取
            const patientReportFile = `/sdcard/test/${this.patientId}.json`;
            const patientReport = readJsonFromFile(patientReportFile);
            
            if (patientReport) {
              // 如果是数组，取第一个元素
              const report = Array.isArray(patientReport) ? patientReport[0] : patientReport;
              
              // 提取稳定性数据
              const stabilityData = {
                patientId: report.id,
                leftBrainImpedance: report.leftBrainImpedance || [],
                rightBrainImpedance: report.rightBrainImpedance || [],
                allBrainImpedance: report.allBrainImpedance || [],
                stabilityWholeBrain: report.stabilityWholeBrain || []
              };
              
              resolve(stabilityData);
              return;
            }
            
            // 如果没有找到患者报告文件，尝试从旧的稳定性数据文件中读取
            const stabilityData = readJsonFromFile('/sdcard/test/stability_data.json') || [];
            // 获取该患者的最新一条监测数据
            const latestStabilityData = stabilityData
              .filter(data => data.patientId === this.patientId)
              .sort((a, b) => new Date(b.createData) - new Date(a.createData))[0];
            resolve(latestStabilityData);
          } catch (error) {
            console.error('获取稳定性数据失败:', error);
            resolve(null);
          }
        }, 0);
      });
    },

    // 新增：预处理报告数据
    async preprocessReportData(reportData) {
      try {
        // 显示预处理提示
        uni.showLoading({
          title: '优化数据中...',
          mask: true
        });
        
        // 创建Web Worker进行数据处理
        const processData = (data, maxPoints = 1000) => {
          if (!data || !Array.isArray(data) || data.length <= maxPoints) {
            return data;
          }
          
          // 根据数据量大小动态调整采样点数
          let targetPoints = maxPoints;
          if (data.length > 20000) {
            targetPoints = 1500; // 超大数据集使用更多点
          } else if (data.length > 10000) {
            targetPoints = 1200; // 大数据集使用较多点
          }
          
          // 对于大数据集，使用更精细的采样策略
          const result = [];
          
          // 添加开始的几个点
          for (let i = 0; i < Math.min(10, data.length); i++) {
            result.push(data[i]);
          }
          
          // 快速找出最大值和最小值
          let maxVal = -Infinity;
          let minVal = Infinity;
          let maxIndex = 0;
          let minIndex = 0;
          
          const scanStep = Math.max(1, Math.floor(data.length / 5000));
          for (let i = 0; i < data.length; i += scanStep) {
            if (data[i] > maxVal) {
              maxVal = data[i];
              maxIndex = i;
            }
            if (data[i] < minVal) {
              minVal = data[i];
              minIndex = i;
            }
          }
          
          // 计算采样间隔
          const step = Math.ceil(data.length / (targetPoints - 20));
          
          // 均匀采样
          for (let i = 10; i < data.length - 10; i += step) {
            result.push(data[i]);
          }
          
          // 确保最大值和最小值被包含
          if (!result.includes(data[maxIndex])) {
            result.push(data[maxIndex]);
          }
          
          if (!result.includes(data[minIndex])) {
            result.push(data[minIndex]);
          }
          
          // 添加结束的几个点
          for (let i = Math.max(0, data.length - 10); i < data.length; i++) {
            result.push(data[i]);
          }
          
          return result;
        };
        
        // 并行处理所有数据
        const [leftBrain, rightBrain, allBrain, wholeBrain] = await Promise.all([
          new Promise(resolve => {
            setTimeout(() => {
              const result = processData(reportData.leftBrainImpedance || []);
              resolve(result);
            }, 0);
          }),
          new Promise(resolve => {
            setTimeout(() => {
              const result = processData(reportData.rightBrainImpedance || []);
              resolve(result);
            }, 0);
          }),
          new Promise(resolve => {
            setTimeout(() => {
              // 对颅内压数据不做任何处理，直接使用原始数据
              console.log('颅内压数据(allBrainImpedance)直接使用，不做采样处理，原始数据长度:', 
                (reportData.allBrainImpedance || []).length);
              console.log('颅内压数据前5个值:', (reportData.allBrainImpedance || []).slice(0, 5));
              resolve(reportData.allBrainImpedance || []);
            }, 0);
          }),
          new Promise(resolve => {
            setTimeout(() => {
              const result = processData(reportData.stabilityWholeBrain || []);
              resolve(result);
            }, 0);
          })
        ]);
        
        // 设置预处理数据
        this.preprocessedReportData = {
          left: leftBrain,
          right: rightBrain,
          icp: allBrain,
          all: wholeBrain
        };
        
        console.log('数据预处理完成:', {
          leftLength: leftBrain.length,
          rightLength: rightBrain.length,
          icpLength: allBrain.length,
          allLength: wholeBrain.length
        });
        
        // 隐藏预处理提示
        uni.hideLoading();
      } catch (error) {
        console.error('预处理报告数据失败:', error);
        // 出错时设置为null，让报告组件自行处理
        this.preprocessedReportData = null;
        uni.hideLoading();
      }
    },
  },

  mounted() {
    this.initUserInfo()
  },

  onLoad(options) {
    if (options.patientId) {
      this.patientId = options.patientId
      this.getPatientInfo()
    }
  },

  created() {
    // 清空阻抗数组数据
    impedanceL = []
    impedanceR = []
    impedanceAll = []

    // 重置显示的值
    this.leftBrainLatestValue = 0
    this.leftBrainMaxValue = 0
    this.rightBrainLatestValue = 0
    this.rightBrainMaxValue = 0
    this.allBrainLatestValue = 0
    this.allBrainMaxValue = 0

    // 重置第一个值
    this.leftBrainFirstValue = null
    this.rightBrainFirstValue = null
    this.allBrainFirstValue = null

    // 清空稳定系数数组
    this.stabilityLeftBrain = []
    this.stabilityRightBrain = []
    this.stabilityAllBrain = []
    this.stabilityWholeBrain = []
    
    // 重置数据收集相关变量
    this.isCollectingInitialData = false
    this.formalMonitoringDataCount = 0
    this.tempLeftBrainData = []
    this.tempRightBrainData = []
    this.tempAllBrainData = []
  },
  beforeDestroy() {
    // 组件销毁前清除计时器
    if (this.monitoringTimer) {
      clearInterval(this.monitoringTimer)
      this.monitoringTimer = null
    }
    
    // 清除数据回放定时器
    if (this.playbackTimer) {
      console.log('组件销毁前清除数据回放定时器');
      clearTimeout(this.playbackTimer)
      this.playbackTimer = null
    }
    
    // 断开蓝牙连接
    if (this.isConnected) {
      console.log('页面卸载时断开蓝牙连接')
      // 标记为手动断开，防止自动重连
      this.isManualDisconnect = true
      // 如果正在监测，先停止监测
      if (this.isMonitoring) {
        writeBLEState(99)
        this.isMonitoring = false
      }
      // 断开蓝牙连接
      uni.closeBLEConnection({
        deviceId: this.$store.state.deviceId,
        success: () => {
          console.log('蓝牙已断开')
          // 更新连接状态
          this.setIsConnected(false)
        },
        fail: (error) => {
          console.error('断开蓝牙连接失败：', error)
        },
        complete: () => {
          // 关闭蓝牙适配器
          uni.closeBluetoothAdapter({
            success: () => {
              console.log('蓝牙适配器已关闭')
            }
          })
        }
      })
    }
  },
}
</script>

<style scoped lang="scss">
@import './styles/monitor.scss';
</style>
